package com.imut.lagain.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.imut.lagain.entity.MemoryEntry;
import com.imut.lagain.repository.MemoryEntryRepository;
import com.imut.lagain.service.IMemoryEntryService;
import com.imut.lagain.service.IMemoryCapsuleService;
import lombok.RequiredArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 记忆条目服务实现类
 */
@Service
@RequiredArgsConstructor
@Transactional
public class MemoryEntryServiceImpl extends ServiceImpl<MemoryEntryRepository, MemoryEntry> implements IMemoryEntryService {
    
    private static final Logger log = LoggerFactory.getLogger(MemoryEntryServiceImpl.class);
    
    private final IMemoryCapsuleService memoryCapsuleService;

    /**
     * 创建记忆条目
     * @param entry 条目信息
     * @return 是否创建成功
     */
    @Override
    public boolean createEntry(MemoryEntry entry) {
        if (entry == null) {
            return false;
        }
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());
        boolean result = this.save(entry);
        if (result && entry.getCapsuleId() != null) {
            memoryCapsuleService.updateLastActiveTime(entry.getCapsuleId());
        }
        return result;
    }

    /**
     * 根据胶囊ID获取所有条目，按排序值和创建时间正序排列
     * @param capsuleId 胶囊ID
     * @return 条目列表
     */
    @Override
    @Transactional(readOnly = true)
    public List<MemoryEntry> getEntriesByCapsuleId(Long capsuleId) {
        if (capsuleId == null) {
            return List.of();
        }
        return baseMapper.findByCapsuleId(capsuleId);
    }

    /**
     * 根据胶囊ID分页获取条目
     * @param capsuleId 胶囊ID
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> getEntriesByCapsuleId(Long capsuleId, Page<MemoryEntry> page) {
        if (capsuleId == null) {
            return new Page<>();
        }
        return baseMapper.findByCapsuleIdWithPage(capsuleId, page);
    }

    /**
     * 根据胶囊ID分页获取条目
     * @param capsuleId 胶囊ID
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesByCapsuleId(Long capsuleId, int pageNum, int pageSize) {
        if (capsuleId == null) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findByCapsuleIdWithPage(capsuleId, page);
    }

    /**
     * 根据胶囊ID分页获取条目
     * @param capsuleId 胶囊ID
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> getEntriesByCapsuleIdWithPage(Long capsuleId, Page<MemoryEntry> page) {
        if (capsuleId == null) {
            return new Page<>();
        }
        return baseMapper.findByCapsuleIdWithPage(capsuleId, page);
    }

    /**
     * 根据胶囊ID分页获取条目
     * @param capsuleId 胶囊ID
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesByCapsuleIdWithPage(Long capsuleId, int pageNum, int pageSize) {
        if (capsuleId == null) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findByCapsuleIdWithPage(capsuleId, page);
    }

    /**
     * 根据条目类型获取条目列表
     * @param entryType 条目类型
     * @return 条目列表
     */
    @Override
    @Transactional(readOnly = true)
    public List<MemoryEntry> getEntriesByType(String entryType) {
        if (!StringUtils.hasText(entryType)) {
            return List.of();
        }
        return baseMapper.findByEntryType(entryType);
    }

    /**
     * 根据条目类型分页获取条目列表
     * @param entryType 条目类型
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> getEntriesByType(String entryType, Page<MemoryEntry> page) {
        if (!StringUtils.hasText(entryType)) {
            return new Page<>();
        }
        return baseMapper.findByEntryType(entryType, page);
    }



    /**
     * 根据条目类型分页获取条目列表
     * @param entryType 条目类型
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesByType(String entryType, int pageNum, int pageSize) {
        if (!StringUtils.hasText(entryType)) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findByEntryType(entryType, page);
    }

    /**
     * 根据时间范围获取条目列表
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return 条目列表
     */
    @Override
    @Transactional(readOnly = true)
    public List<MemoryEntry> getEntriesByTimeRange(LocalDateTime startTime, LocalDateTime endTime) {
        if (startTime == null || endTime == null) {
            return List.of();
        }
        return baseMapper.findByCreateTimeBetween(startTime, endTime);
    }

    /**
     * 根据时间范围分页获取条目列表
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> getEntriesByTimeRange(LocalDateTime startTime, LocalDateTime endTime, Page<MemoryEntry> page) {
        if (startTime == null || endTime == null) {
            return new Page<>();
        }
        return baseMapper.findByCreateTimeBetween(startTime, endTime, page);
    }

    /**
     * 按创建时间范围查询条目
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> getEntriesByCreateTimeBetween(LocalDateTime startTime, LocalDateTime endTime, Page<MemoryEntry> page) {
        if (startTime == null || endTime == null) {
            return new Page<>();
        }
        return baseMapper.findByCreateTimeBetween(startTime, endTime, page);
    }

    /**
     * 按创建时间范围查询条目
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesByCreateTimeBetween(LocalDateTime startTime, LocalDateTime endTime, int pageNum, int pageSize) {
        if (startTime == null || endTime == null) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        IPage<MemoryEntry> result = baseMapper.findByCreateTimeBetween(startTime, endTime, page);
        return (Page<MemoryEntry>) result;
    }

    /**
     * 根据时间范围查询条目（按用户ID）
     * @param userId 用户ID
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesByTimeRange(Long userId, LocalDateTime startTime, LocalDateTime endTime, int pageNum, int pageSize) {
        if (startTime == null || endTime == null) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findByUserIdAndCreateTimeBetween(userId, startTime, endTime, page);
    }

    /**
     * 根据胶囊ID和条目类型查询
     * @param capsuleId 胶囊ID
     * @param entryType 条目类型
     * @return 条目列表
     */
    @Override
    @Transactional(readOnly = true)
    public List<MemoryEntry> getEntriesByCapsuleIdAndType(Long capsuleId, String entryType) {
        if (capsuleId == null || !StringUtils.hasText(entryType)) {
            return List.of();
        }
        return baseMapper.findByCapsuleIdAndEntryType(capsuleId, entryType);
    }

    /**
     * 根据胶囊ID和条目类型分页查询
     * @param capsuleId 胶囊ID
     * @param entryType 条目类型
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesByCapsuleIdAndType(Long capsuleId, String entryType, Page<MemoryEntry> page) {
        if (capsuleId == null || !StringUtils.hasText(entryType)) {
            return new Page<>();
        }
        return (Page<MemoryEntry>) baseMapper.findByCapsuleIdAndType(capsuleId, entryType, page);
    }

    /**
     * 根据胶囊ID和条目类型分页查询
     * @param capsuleId 胶囊ID
     * @param entryType 条目类型
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesByCapsuleIdAndType(Long capsuleId, String entryType, int pageNum, int pageSize) {
        if (capsuleId == null || !StringUtils.hasText(entryType)) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findByCapsuleIdAndType(capsuleId, entryType, page);
    }

    /**
     * 根据文件URL查询条目
     * @param fileUrl 文件URL
     * @return 条目信息
     */
    @Override
    @Transactional(readOnly = true)
    public MemoryEntry getEntryByFileUrl(String fileUrl) {
        if (!StringUtils.hasText(fileUrl)) {
            return null;
        }
        return baseMapper.findByFileUrl(fileUrl);
    }

    /**
     * 统计条目数量
     * @param capsuleId 胶囊ID（null表示所有胶囊）
     * @param entryType 条目类型（null表示所有类型）
     * @param hasFile 是否包含文件（null表示所有）
     * @return 条目数量
     */
    @Override
    @Transactional(readOnly = true)
    public Long countEntries(Long capsuleId, String entryType, Boolean hasFile) {
        QueryWrapper<MemoryEntry> wrapper = new QueryWrapper<>();
        if (capsuleId != null) {
            wrapper.eq("capsule_id", capsuleId);
        }
        if (StringUtils.hasText(entryType)) {
            wrapper.eq("entry_type", entryType);
        }
        if (hasFile != null) {
            if (hasFile) {
                wrapper.isNotNull("file_path").ne("file_path", "");
            } else {
                wrapper.and(w -> w.isNull("file_path").or().eq("file_path", ""));
            }
        }
        wrapper.eq("is_deleted", 0);
        return baseMapper.selectCount(wrapper);
    }

    /**
     * 更新条目排序
     * @param entryId 条目ID
     * @param sortOrder 新的排序值
     * @return 是否更新成功
     */
    @Override
    public boolean updateSortOrder(Long entryId, Integer sortOrder) {
        if (entryId == null || sortOrder == null) {
            return false;
        }
        int result = baseMapper.updateSortOrder(entryId, sortOrder);
        return result > 0;
    }

    /**
     * 批量更新条目排序
     * @param entryIds 条目ID列表
     * @param sortOrders 对应的排序值列表
     * @return 更新的条目数量
     */
    @Override
    public int batchUpdateSortOrder(List<Long> entryIds, List<Integer> sortOrders) {
        if (entryIds == null || sortOrders == null || entryIds.size() != sortOrders.size()) {
            return 0;
        }
        int result = 0;
        for (int i = 0; i < entryIds.size(); i++) {
            if (baseMapper.updateSortOrder(entryIds.get(i), sortOrders.get(i)) > 0) {
                result++;
            }
        }
        return result;
    }

    /**
     * 根据内容模糊查询条目
     * @param content 内容关键字
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> searchEntriesByContent(String content, Page<MemoryEntry> page) {
        if (!StringUtils.hasText(content)) {
            return new Page<>();
        }
        return baseMapper.findByContentLike(content, page);
    }

    /**
     * 根据内容模糊查询条目
     * @param content 内容关键字
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> searchEntriesByContent(String content, int pageNum, int pageSize) {
        if (!StringUtils.hasText(content)) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findByContentLike(content, page);
    }

    /**
     * 在指定胶囊中根据内容模糊查询条目
     * @param capsuleId 胶囊ID
     * @param content 内容关键字
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> searchEntriesByContentInCapsule(Long capsuleId, String content, Page<MemoryEntry> page) {
        if (capsuleId == null || !StringUtils.hasText(content)) {
            return new Page<>();
        }
        return baseMapper.findByContentLikeInCapsule(capsuleId, content, page);
    }

    /**
     * 在指定胶囊中根据内容模糊查询条目
     * @param capsuleId 胶囊ID
     * @param content 内容关键字
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> searchEntriesByContentInCapsule(Long capsuleId, String content, int pageNum, int pageSize) {
        if (capsuleId == null || !StringUtils.hasText(content)) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findByContentLikeInCapsule(capsuleId, content, page);
    }

    /**
     * 查询包含文件的条目
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> getEntriesWithFiles(Page<MemoryEntry> page) {
        return baseMapper.findEntriesWithFiles(page);
    }
    
    /**
     * 查询包含文件的条目
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> getEntriesWithFiles(int pageNum, int pageSize) {
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.findEntriesWithFiles(page);
    }

    /**
     * 根据用户ID获取所有记忆条目
     * @param userId 用户ID
     * @return 条目列表
     */
    @Override
    @Transactional(readOnly = true)
    public List<MemoryEntry> getEntriesByUserId(Long userId) {
        if (userId == null) {
            return List.of();
        }
        return baseMapper.findByUserId(userId);
    }

    /**
     * 统计包含文件的条目数量
     * @param capsuleId 胶囊ID（null表示所有胶囊）
     * @return 条目数量
     */
    @Override
    @Transactional(readOnly = true)
    public Long countEntriesWithFiles(Long capsuleId) {
        QueryWrapper<MemoryEntry> wrapper = new QueryWrapper<>();
        if (capsuleId != null) {
            wrapper.eq("capsule_id", capsuleId);
        }
        wrapper.isNotNull("file_path").ne("file_path", "");
        wrapper.eq("is_deleted", 0);
        return baseMapper.selectCount(wrapper);
    }

    /**
     * 按文件类型查询条目
     * @param fileType 文件类型
     * @param page 分页参数
     * @return 条目分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public IPage<MemoryEntry> getEntriesByFileType(String fileType, Page<MemoryEntry> page) {
        if (!StringUtils.hasText(fileType)) {
            return new Page<>();
        }
        return baseMapper.findByFileType(fileType, page);
    }

    /**
     * 恢复已删除的条目
     * @param entryId 条目ID
     * @return 是否恢复成功
     */
    @Override
    public boolean restoreEntry(Long entryId) {
        if (entryId == null) {
            return false;
        }
        MemoryEntry entry = this.getById(entryId);
        if (entry == null) {
            return false;
        }
        entry.setIsDeleted(false);
        entry.setUpdateTime(LocalDateTime.now());
        return this.updateById(entry);
    }

    /**
     * 更新条目信息
     * @param entry 条目信息
     * @return 是否更新成功
     */
    @Override
    public boolean updateEntry(MemoryEntry entry) {
        if (entry == null || entry.getId() == null) {
            return false;
        }
        entry.setUpdateTime(LocalDateTime.now());
        boolean result = this.updateById(entry);
        if (result && entry.getCapsuleId() != null) {
            memoryCapsuleService.updateLastActiveTime(entry.getCapsuleId());
        }
        return result;
    }

    /**
     * 搜索记忆条目
     * @param userId 用户ID
     * @param keyword 关键字
     * @param capsuleId 胶囊ID
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 搜索结果分页列表
     */
    @Override
    @Transactional(readOnly = true)
    public Page<MemoryEntry> searchEntries(Long userId, String keyword, Long capsuleId, int pageNum, int pageSize) {
        if (userId == null) {
            return new Page<>();
        }
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        return (Page<MemoryEntry>) baseMapper.searchEntries(userId, keyword, capsuleId, page);
    }

    /**
     * 软删除条目
     * @param entryId 条目ID
     * @return 是否删除成功
     */
    @Override
    public boolean softDeleteEntry(Long entryId) {
        if (entryId == null) {
            return false;
        }
        
        MemoryEntry entry = this.getById(entryId);
        if (entry == null) {
            return false;
        }
        
        entry.setIsDeleted(true);
        entry.setUpdateTime(LocalDateTime.now());
        boolean result = this.updateById(entry);
        if (result && entry.getCapsuleId() != null) {
            memoryCapsuleService.updateLastActiveTime(entry.getCapsuleId());
        }
        return result;
    }
    

    
    /**
     * 更新记忆条目内容
     * @param entryId 条目ID
     * @param content 新内容
     * @return 是否更新成功
     */
    @Override
    public boolean updateEntry(Long entryId, String content) {
        if (entryId == null || content == null) {
            return false;
        }
        
        MemoryEntry entry = this.getById(entryId);
        if (entry == null) {
            return false;
        }
        
        entry.setContent(content);
        entry.setUpdateTime(LocalDateTime.now());
        boolean result = this.updateById(entry);
        if (result && entry.getCapsuleId() != null) {
            memoryCapsuleService.updateLastActiveTime(entry.getCapsuleId());
        }
        return result;
    }

    /**
     * 删除记忆条目
     * @param entryId 条目ID
     * @return 是否删除成功
     */
    @Override
    public boolean deleteEntry(Long entryId) {
        try {
            MemoryEntry entry = baseMapper.selectById(entryId);
            if (entry != null) {
                entry.setIsDeleted(true);
                entry.setDeletedAt(LocalDateTime.now());
                return baseMapper.updateById(entry) > 0;
            }
            return false;
        } catch (Exception e) {
            log.error("删除记忆条目失败", e);
            return false;
        }
    }



    @Override
    public Page<MemoryEntry> getEntriesWithFiles(Long userId, int pageNum, int pageSize) {
        Page<MemoryEntry> page = new Page<>(pageNum, pageSize);
        QueryWrapper<MemoryEntry> queryWrapper = new QueryWrapper<>();
        queryWrapper.isNotNull("file_url")
                   .ne("file_url", "")
                   .eq("is_deleted", false)
                   .exists("SELECT 1 FROM memory_capsule mc WHERE mc.id = memory_entry.capsule_id AND mc.user_id = {0} AND mc.is_deleted = 0", userId)
                   .orderByDesc("create_time");
        IPage<MemoryEntry> result = baseMapper.selectPage(page, queryWrapper);
        return (Page<MemoryEntry>) result;
    }

    /**
     * 创建视频条目（带用户ID和文件URL）
     * @param capsuleId 胶囊ID
     * @param userId 用户ID
     * @param fileUrl 文件URL
     * @param content 描述内容
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createVideoEntry(Long capsuleId, Long userId, String fileUrl, String content) {
        if (capsuleId == null || userId == null || !StringUtils.hasText(fileUrl)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("VIDEO");
        entry.setContent(content);
        entry.setFileUrl(fileUrl);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建文本条目
     * @param capsuleId 胶囊ID
     * @param content 文本内容
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createTextEntry(Long capsuleId, String content) {
        if (capsuleId == null || !StringUtils.hasText(content)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("TEXT");
        entry.setContent(content);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建文本条目
     * @param capsuleId 胶囊ID
     * @param userId 用户ID
     * @param content 文本内容
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createTextEntry(Long capsuleId, Long userId, String content) {
        // userId参数在当前实体设计中未使用，但为了接口一致性保留
        if (capsuleId == null || !StringUtils.hasText(content)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("TEXT");
        entry.setContent(content);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建图片条目
     * @param capsuleId 胶囊ID
     * @param fileUrl 图片URL
     * @param fileName 文件名
     * @param fileSize 文件大小
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createImageEntry(Long capsuleId, String fileUrl, String fileName, Long fileSize) {
        if (capsuleId == null || !StringUtils.hasText(fileUrl)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("IMAGE");
        entry.setFileUrl(fileUrl);
        entry.setFileName(fileName);
        entry.setFileSize(fileSize);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建图片条目（简化版本）
     * @param capsuleId 胶囊ID
     * @param content 描述内容
     * @param fileName 文件名
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createImageEntry(Long capsuleId, String content, String fileName) {
        if (capsuleId == null) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("IMAGE");
        entry.setContent(content);
        entry.setFileName(fileName);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建图片条目（带用户ID和文件URL）
     * @param capsuleId 胶囊ID
     * @param userId 用户ID
     * @param fileUrl 文件URL
     * @param content 描述内容
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createImageEntry(Long capsuleId, Long userId, String fileUrl, String content) {
        // userId参数在当前实体设计中未使用，但为了接口一致性保留
        if (capsuleId == null || !StringUtils.hasText(fileUrl)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("IMAGE");
        entry.setFileUrl(fileUrl);
        entry.setContent(content);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建语音条目
     * @param capsuleId 胶囊ID
     * @param fileUrl 语音URL
     * @param fileName 文件名
     * @param fileSize 文件大小
     * @param duration 语音时长（秒）
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createAudioEntry(Long capsuleId, String fileUrl, String fileName, Long fileSize, Integer duration) {
        if (capsuleId == null || !StringUtils.hasText(fileUrl)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("AUDIO");
        entry.setFileUrl(fileUrl);
        entry.setFileName(fileName);
        entry.setFileSize(fileSize);
        entry.setDuration(duration);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建语音条目（简化版本）
     * @param capsuleId 胶囊ID
     * @param content 描述内容
     * @param fileName 文件名
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createAudioEntry(Long capsuleId, String content, String fileName) {
        if (capsuleId == null) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("AUDIO");
        entry.setContent(content);
        entry.setFileName(fileName);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建语音条目（带用户ID和文件URL）
     * @param capsuleId 胶囊ID
     * @param userId 用户ID
     * @param fileUrl 文件URL
     * @param content 描述内容
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createAudioEntry(Long capsuleId, Long userId, String fileUrl, String content) {
        // userId参数在当前实体设计中未使用，但为了接口一致性保留
        if (capsuleId == null || !StringUtils.hasText(fileUrl)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("AUDIO");
        entry.setFileUrl(fileUrl);
        entry.setContent(content);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建视频条目
     * @param capsuleId 胶囊ID
     * @param fileUrl 视频URL
     * @param fileName 文件名
     * @param fileSize 文件大小
     * @param duration 视频时长（秒）
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createVideoEntry(Long capsuleId, String fileUrl, String fileName, Long fileSize, Integer duration) {
        if (capsuleId == null || !StringUtils.hasText(fileUrl)) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("VIDEO");
        entry.setFileUrl(fileUrl);
        entry.setFileName(fileName);
        entry.setFileSize(fileSize);
        entry.setDuration(duration);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }

    /**
     * 创建视频条目（简化版本）
     * @param capsuleId 胶囊ID
     * @param content 描述内容
     * @param fileName 文件名
     * @return 创建的条目
     */
    @Override
    public MemoryEntry createVideoEntry(Long capsuleId, String content, String fileName) {
        if (capsuleId == null) {
            return null;
        }

        MemoryEntry entry = new MemoryEntry();
        entry.setCapsuleId(capsuleId);
        entry.setEntryType("VIDEO");
        entry.setContent(content);
        entry.setFileName(fileName);
        entry.setCreateTime(LocalDateTime.now());
        entry.setUpdateTime(LocalDateTime.now());

        boolean result = this.save(entry);
        if (result) {
            memoryCapsuleService.updateLastActiveTime(capsuleId);
            return entry;
        }
        return null;
    }
}